The Expressive Power of Memory Logics

We investigate the expressive power of memory logics. These are modal logics extended with the possibility to store (or remove) the current node of evaluation in (or from) a memory, and to perform membership tests on the current memory. From this perspective, the hybrid logic HL(↓), for example, can be thought of as a particular case of a memory logic where the memory is an indexed list of elements of the domain. This work focuses in the case where the memory is a set, and we can test whether the current node belongs to the set or not. We prove that, in terms of expressive power, the memory logics we discuss here lie between the basic modal logic K and HL(↓). We show that the satisfiability problem of most of the logics we cover is undecidable. The only logic with a decidable satisfiability problem is obtained by imposing strong constraints on which elements can be memorized. §1. Modal logics and memory logics. Nowadays, the term modal logics loosely refers to an extremely wide variety of languages, which are used in many different applications (see e.g., Blackburn et al., 2006). Actually, the fact that the number of members in this family keeps constantly increasing is one of the defining characteristic of the field. While most modal logics have certain general aspects in common (e.g., they are usually interpreted in terms of relational structures and they are computationally well behaved), there usually are as many modal logics satisfying any of these “characterizing properties” as there are modal logics not honoring them. As a result, it is very hard indeed to come up with a proper definition of what a modal logic is. Perhaps one of the few general traits of the field is the desire to investigate languages specially tailored for specific tasks. In this article we investigate the expressive power of a family of modal logics called memory logics, which extend both the semantics and the syntax of the classical modal logic. Many logical properties of memory logics have been investigated in recent articles. The original idea was introduced in Areces (2007). Areces et al. (2009a) investigate tableau algorithms and model checking for memory logics, while Areces et al. (2009b) discuss axiomatic completeness results. In this article we extend results originally presented in Areces et al. (2008) and provide full proofs. Received: June 7, 2010 c © Association for Symbolic Logic, 2011 290 doi:10.1017/S1755020310000389 THE EXPRESSIVE POWER OF MEMORY LOGICS 291 We will introduce and motivate memory logics now. We need first some basic definitions. Let S be a first-order relational signature (i.e., a first-order signature without function and constant symbols), and let M = 〈D, I〉 be a relational structure interpreting S (i.e., D is a nonempty set and I is an interpretation function that assigns to all relational symbols in S a relation of the correct arity). It is well known that the basic modal language K can be interpreted on M (see Blackburn et al., 2001 for details). When interpreting modal formulas on relational structures, elements in the domain are sometimes called states, and the interpretations of relational symbols are called accessibility relations. It is often said that modal languages provide an internal perspective of the structures over which they are evaluated. As Blackburn et al. (2001) put it, “a modal formula [can be seen as] a little automaton standing at some state in a relational structure, and only permitted to explore the structure by making journeys to neighboring states.” It is natural to think of a modal formula as exploring the structure, but what about changing it? Suppose we want to grant our little automaton the additional power to modify the structure during its exploratory trips. This question is not new, and it has resulted in different proposals of what are called dynamic logics. Consider, for example, the task of assigning semantics to a programming language. Clearly, the different instructions of the language change the computational state. It is then natural to define their semantics by specifying which changes each atomic operation of the language introduces. This idea is at the core of formalisms like Hoare–Floyd logics (Floyd, 1967; Hoare, 1969) which include, for example, special operators to indicate the state of variables before and after a given instruction. As a second example, consider the area of linguistics called dynamic semantics. One of its fundamental claims is that the standard truth-conditional view of sentence meaning—which is the result of using classical logic as representation languages—does not do sufficient justice to the fact that uttering a sentence changes the context it was uttered in. Deriving inspiration, in part, from work on the semantics of programming languages, dynamic semantic theories have developed several variations on the idea that the meaning of a sentence should be equated with the changes it makes to a context. Different dynamic logics like those introduced by Groenendijk & Stokhof (1991a, 1991b) try to capture these ideas. As yet a third example with an ample literature, we can mention dynamic epistemic logics (Plaza, 1989; Gerbrandy, 1999; van Benthem, 2001, 2005; van Benthem et al., 2006; van Ditmarsch et al., 2007). These logics model the evolution of the knowledge of epistemic agents via updates to the model representing their epistemic state. For example, some of these languages represent the act of an agent updating its epistemic state with the information that φ is true by eliminating all alternative epistemic states where ¬φ holds. Our last family of examples come from the area of temporal logics for verification. In this area, it is many times necessary to model time-critical systems that depend on quantitative rather than qualitative properties. Many temporal logics introduced for this task use explicit global clocks which are accessed and controlled through logical operators. Examples of such logics are Explicit Clock Temporal Logic (XCTL) (Harel et al., 1990), half-order logics (Alur & Henzinger, 1989; Henzinger, 1990), and timed and metric temporal logics (Alur et al., 1993, 1996; Koymans, 1990; Ouaknine & Worrell, 2005). By contrast, other logics which are also called dynamic are not dynamic in the sense mentioned above, the main example being Propositional Dynamic Logic (PDL) (Harel, 1984). In PDL formulas are evaluated in a model but they cannot modify it (even though the language does include special operators to verify that certain property holds in a given 292 CARLOS ARECES ET AL. state and continue evaluation accordingly, which provide extended expressivity (Berman & Paterson, 1981)). Memory logics can be seen as an attempt to investigate some of the common characteristics of all these logics, in the simplest possible set up. Going back to our little automaton, suppose we extend our definition of a model to a triple M = 〈D, I, M〉, where M is an arbitrary subset of D. We can think of M as a memory where the automaton can store states that are considered particularly interesting. Defining the semantics of this operator is straightforward. Let us write 〈D, I, M〉, w | φ for w ∈ D and φ a formula to indicate that φ is true at w in the relational structure 〈D, I〉 extended with the memory M . Let us use ©r (‘remember’) to represent the memorize operator. We can then define 〈D, I, M〉, w | ©r φ iff 〈D, I, M ∪ {w}〉, w | φ. In other words, ©r is an instruction to modify the memory of the model, and φ is evaluated in the modified structure. The operation ©r by itself is totally useless. If we cannot access the information stored in M , ©r φ is equivalent to φ. Let us add then an operator ©k (‘known’) that checks whether the current state has been previously remembered: 〈D, I, M〉, w | ©k iff w ∈ M. This simple language gives us already new tautologies. For example, it is easy to see that the formula ©r©k is always true. It is also not difficult to see (using well-known results from modal logic) that the memory logic operator gives us additional expressivity. Let us remind the semantics of the standard (unary) modal operator diamond 〈r〉 of the basic modal language 1. Assuming that I(r) is a binary relation, we define: 〈D, I, M〉, w | 〈r〉φ iff for some w′ ∈ D s.t. (w,w′) ∈ I(r) 〈D, I, M〉, w′ | φ. That is, the formula 〈r〉φ is true in a state w if the formula φ is true in an r -successor. Now, the memory logic formula ©r 〈r〉©k is true in a state when evaluated on a model with an empty memory if and only if it is self reachable via the accessibility relation I(r). That is, 〈D, I,∅〉, w | ©r 〈r〉©k iff (w,w) ∈ I(r). As formulas of the basic modal language have the tree model property (i.e., a formula is satisfiable if and only if it is satisfiable in model which is a tree, and hence it does not contain reflexive loops (Blackburn et al., 2001)), this property cannot be expressed in the basic modal language. In the same spirit of the operators ©r and ©k introduced above, we can naturally define operators that modify any element of a model (adding or deleting states or modifying the interpretation function). In this paper we will restrict ourselves to operators that can access and modify only the memory M (even though we will briefly discuss possible alternative structures for M). In Section §2 we will formally introduce the syntax and semantics of the memory logics we will investigate. In Section §3 we will define suitable notions of model equivalence for each language, which we will use in Section §4 to investigate their expressive power. In Section §5 we will show that most of the languages obtained, even in this simple setup, are undecidable. We show one case where decidability is regained by imposing a very strict ‘memorization policy’. Section §6 finishes the paper with our conclusions and ideas for future work. 1 Of course, the operator is usually defined on models without memory. We will define it so that it does not interact with the memory M . THE EXPRESSIVE POWER OF MEMORY LOGICS 293 We close this section with some additional details on how memory logics were originally conceived, and how they relate to binding and hybrid logics. 1.1. Memory logics and hybrid logics, or how memory logics were born. Memory logics where initially defined for purely theoretical reasons (related to questions concerning binding and decidability), but it soon became clear that they could provide an interesting perspective on the question of how a formula can modify the model in which it is being evaluated, as we discussed above. Memory logics were originally inspired by hybrid logics containing binders like HL(↓) (see Areces & ten Cate, 2006). But while ↓ was introduced to investigate dynamic naming of elements in a model, memory logics include operators to store and retrieve information from some kind of information structure or memory. In any case, once we take the appropriate point of view HL(↓) can be considered the first memory logic. Let us start by formally introducing HL(↓). Assume a signature S = 〈PROP, NOM, REL〉, where PROP, NOM, and REL are countably infinite, pairwise disjoint sets of propositional, nominal, and relational symbols respectively. For simplicity, and as it is usually done with modal languages, we will only introduce unary modal operators2. The syntax of HL(↓) is defined as follows φ ::= | p | i | ¬φ | φ ∧ φ | 〈r〉φ | ↓i.φ, where p ∈ PROP, i ∈ NOM, and r ∈ REL. We can see that the language of HL(↓) is the language of the basic modal logic K (see Blackburn et al., 2001 for details) extended with nominals and ↓i . Semantically, HL(↓) is also very close to K. HL(↓)-formulas are interpreted on relational structures extended with an assignment function to interpret nominals. Formally, a model for HL(↓) is a tuple 〈D, I, g〉 where g : NOM → D is an assignment function. I assigns a subset of D to elements in PROP, and a binary relation on D to elements of REL. Given 〈D, I, g〉, the semantic conditions for HL(↓) are defined as: 〈D, I, g〉, w | iff always 〈D, I, g〉, w | p iff w ∈ I(p) 〈D, I, g〉, w | i iff g(i) = w 〈D, I, g〉, w | ¬φ iff 〈D, I, g〉, w | φ 〈D, I, g〉, w | φ ∧ ψ iff 〈D, I, g〉, w | φ and 〈D, I, g〉, w | ψ 〈D, I, g〉, w | 〈r〉φ iff there is w′ s.t. (w,w′) ∈ I(r) and 〈D, I, g〉, w′ | φ 〈D, I, g〉, w | ↓i.φ iff 〈D, I, g′〉, w | φ where g′( j) = g( j) for j = i and g′(i) = w. One way of looking at the semantic condition for ↓i.φ is that it dynamically creates a name for the current state (by linking the nominal i to it), so that we can later refer to it during the evaluation of φ. An alternative perspective is to see ↓i as an instruction to modify the model (by storing the current point of evaluation into i), and continue the evaluation of φ in the modified model. The difference between the two perspectives is subtle, but important for this article. In the latter, we are considering the assignment g as a kind of memory in our model, while ↓i and i are the tools we use to access the memory for reading and writing. The question then presents itself naturally: are there other kinds of interesting memory structures and memory operators? 2 Actually, we will restrict ourselves to unary modalities through the article. 294 CARLOS ARECES ET AL. The assignment g is a very sophisticated memory structure: it has unbounded size, it provides direct access to all its memory cells, and each stored element can be unequivocally retrieved. The memory M we discussed above, together with the operators ©r and ©k , provides a much simpler memory structure. Intuitively, these operators cannot discern between different states stored in M , while an assignment g keeps a complete mapping between states and nominals. But notice that ©r is a binder, and effectively binds instances of ©k appearing in its scope. In other words, as we can see ↓i and nominals as memory operators which store and retrieve information from a memory structure, we could see ©r as a binder that binds occurrences of ©k in its scope. As the memory structure used by ©r and ©k has less discerning power, we would expect that the logic containing the new operators is less expressive than HL(↓). §2. Syntax and semantics for memory logics. In this section we will introduce the syntax and semantics of the different memory logics that we will discuss in the article, and fix some terminology. All the languages we will introduce are obtained by extending (in some cases, also slightly modifying) the syntax and semantics of the basic modal logic. Furthermore, with the exception of one case in which we discuss using a stack as a memory container, all the logics we analyze have the operators ©r and ©k . Therefore, for notational convention, we will use ML (for memory logics) as a prefix indicating a language that uses a set as a container, and that includes ©r and ©k . Then we will list the additional operators included in the language. Since the usual semantics of the diamond operator is going to be slightly modified in some cases, we will also include the diamond explicitly in this list. For example, ML(〈r〉) is basic modal logic (i.e., with the usual diamond operator) extended with ©r and ©k . DEFINITION 2.1 (Syntax). Let PROP = {p1, p2, . . . } (the propositional symbols) and REL = {r1, r2, . . . } (the relational symbols) be disjoint, countable infinite sets. The set FORMS of formulas in the signature 〈PROP, REL〉 is defined as: FORMS ::= | p | ¬φ | φ1 ∧ φ2 | 〈r〉φ | 〈〈r〉〉φ | ©k | ©r φ where p ∈ PROP, r ∈ REL, and φ, φ1, φ2 ∈ FORMS. The other standard operators are introduced via definitions. In particular [r ]φ := ¬〈r〉¬φ and [[r ]]φ := ¬〈〈r〉〉¬φ. Throughout this article we are going to use the usual notion of modal depth of a formula, that is, the deepest nesting of modal operators. Modal formulas without modal operators have a modal depth of zero. DEFINITION 2.2 (Semantics). Given a signature S = 〈PROP, REL〉, a model is a tuple M = 〈D, I, M〉 where D is a nonempty set, I is an interpretation function such that I(p) ⊆ D for p ∈ PROP and I(r) ⊆ D × D for r ∈ REL. M ⊆ D will be called the memory of the model. For notational convenience, let us assume fixed for the rest of the article the models M = 〈D, I, M〉, M1 = 〈D1, I1, M1〉, and M2 = 〈D2, I2, M2〉. Given a model M and a list of states [w1, . . . , wn], wi ∈ D, we define M[w1, . . . , wn] = 〈D, I, M ∪ {w1, . . . , wn}〉. Now, let M be a model and w ∈ D, then the semantics for the different operators is defined as: M, w | iff always M, w | p iff w ∈ I(p) THE EXPRESSIVE POWER OF MEMORY LOGICS 295 M, w | ¬φ iff M, w | φ M, w | φ ∧ ψ iff M, w | φ and M, w | ψ M, w | 〈r〉φ iff there is w′ such that (w,w′) ∈ I(r) and M, w′ | φ M, w | 〈〈r〉〉φ iff there is w′ such that (w,w′) ∈ I(r) and M[w], w′ | φ M, w | ©r φ iff M[w], w | φ M, w | ©k iff w ∈ M. Given a model M and w ∈ D, the set of propositions that are true at a given state w is defined as props(w) = {p ∈ PROP | w ∈ I(p)}. Given two models M1 and M2, and states w1 ∈ D1 and w2 ∈ D2, we say that they agree when props(w1) = props(w2) and w1 ∈ M1 iff w2 ∈ M2. Given a model M and w in the domain of M, we call 〈M, w〉 a pointed model. A particularly interesting class of models to investigate is the class C∅ = {M | M = 〈D, I,∅〉}, that is, the class of models where the memory is empty. Since we are working with logics that deal with the notion of state, it is natural to consider starting to evaluate a formula in a model of C∅. It is over C∅ that the operators ©k and ©r have the most natural interpretation, and as we will see in the next sections, the restriction to this class has important effects on expressivity and decidability. It is worth noting that in this case a formula is initially evaluated in a model of C∅, but during the evaluation the model can change to one with nonempty memory. We will put an empty set as a subscript on the prefix ML every time we work with C∅ as the class of initial models. For example ML(〈r〉) restricted to this class of initial models is ML∅(〈r〉). We will not consider all possible combinations of operators, since it is not our intention to be completely exhaustive. We are only going to analyze some combinations that we consider interesting, and in each section we will indicate the fragments we will be using. In many cases, the results shown for some fragments can be easily transferred to other fragments, not explicitly analyzed. §3. Model equivalence. In this section we will investigate the notion of model equivalence for some of the memory logics that we introduced. Our goal is to define tools that will help us to investigate their expressive power. In particular, we will define a notion of model equivalence in terms of Ehrenfeucht–Fraı̈ssé games (Ebbinghaus et al., 1984) and then introduce an alternative, but equivalent, notion in terms of bisimulations. DEFINITION 3.1 (Ehrenfeucht–Fraı̈ssé Games). Let M1 and M2 be two models and let w1 ∈ D1 and w2 ∈ D2. An Ehrenfeucht–Fraı̈ssé game EF(M1,M2, w1, w2) is defined as follows. There are two players called Spoiler and Duplicator. Duplicator immediately looses the game EF(M1,M2, w1, w2) if w1 and w2 do not agree (i.e., either props(w1) = props(w2) or one of the states is in the memory and the other is not). Otherwise, the game starts, with the players moving alternatively. Spoiler always starts a turn of the game choosing in which model he will make a move. Let us set s = 1 and d = 2 in case he chooses M1; otherwise, let s = 2 and d = 1. For the logics ML(〈r〉) and ML∅(〈r〉), the possible moves are as follows: 1. Memorize: Spoiler extends Ms to Ms ∪ {ws}. The next turn then starts with EF (M1[w1],M2[w2], w1, w2) (Duplicator does nothing in this case). 296 CARLOS ARECES ET AL. 2. Chose Successor: Spoiler chooses r ∈ REL, and vs , an Is(r)-successor of ws . If ws has no Is(r)-successors, then Duplicator wins. Duplicator has to chose vd , an Id(r)successor of wd , such that vs and vd agree. If there is no such successor, Spoiler wins. Otherwise the game continues with EF(M1,M2, v1, v2). The moves for the logics ML(〈〈r〉〉) and ML∅(〈〈r〉〉) are similar, except that during a chose successor step Spoiler always remembers the current state, that is, the game continues with EF(M1[w1],M2[w2], v1, v2) after Duplicator response. In the case of an infinite game, Duplicator wins. Note that with this definition, exactly one of Spoiler or Duplicator wins each game. Given two pointed models 〈M1, w1〉 and 〈M2, w2〉 we write 〈M1, w1〉 ≡EF 〈M2, w2〉 when Duplicator has a winning strategy for EF(M1,M2, w1, w2) (the exact type of game involved will usually be clear from the context, and we will write ≡EF L when we need to specify that the game corresponds to the language of the logic L). Even though in the rest of the article we will use the game notion of model equivalence, a structural notion can be given that is closer to the usual notion of bisimulation for modal logics. Both definitions are equivalent, but depending on the context, one can be more natural than the other (e.g., in Mera (2009) the structural notion is used to prove results related to Craig’s interpolation). DEFINITION 3.2 (Bisimulations). Let M1 and M2 be two models. Let ∼ be a binary relation between ℘(D1)× D1 and ℘(D2)× D2. For ML(〈r〉) and ML∅(〈r〉) a bisimulation satisfies the following properties: (nontriv) ∼ is not empty. (agree) If 〈M,m〉 ∼ 〈N , n〉, then m and n agree. (forth) If 〈M,m〉 ∼ 〈N , n〉 and (m,m′) ∈ I1(r), then there exists n′ ∈ D2 such that (n, n′) ∈ I2(r) and 〈M,m′〉 ∼ 〈N , n′〉. (back) If 〈M,m〉 ∼ 〈N , n〉 and (n, n′) ∈ I2(r), then there exists m ′ ∈ D1 such that (m,m′) ∈ I1(r) and 〈M,m′〉 ∼ 〈N , n′〉. (remember) If 〈M,m〉 ∼ 〈N , n〉, then 〈M ∪ {m},m〉 ∼ 〈N ∪ {n}, n〉. For the logics ML(〈〈r〉〉) and ML∅(〈〈r〉〉) the (back) and (forth) conditions are replaced by: (mforth) If 〈M,m〉 ∼ 〈N , n〉 and (m,m′) ∈ I1(r), then there exists n′ ∈ D2 such that (n, n′) ∈ I2(r) and 〈M ∪ {m},m′〉 ∼ 〈N ∪ {n}, n′〉. (mback) If 〈M,m〉 ∼ 〈N , n〉 and (n, n′) ∈ I2(r), then there exists m′ ∈ D1 such that (m,m′) ∈ I1(r) and 〈M ∪ {m},m′〉 ∼ 〈N ∪ {n}, n′〉. Given two pointed models 〈M1, w1〉 and 〈M2, w2〉 we write 〈M1, w1〉 ↔ 〈M2, w2〉 if there is a bisimulation linking 〈M1, w1〉 and 〈M2, w2〉. Again, the exact type of bisimulation involved will usually be clear from the context, and we will write ↔L when we need to specify that the bisimulation corresponds to the logic L. As we said before, the notions of Ehrenfeucht–Fraı̈ssé games and bisimulations coincide, as indicated in the following theorem. THEOREM 3.3. Let L ∈ {ML(〈r〉),ML∅(〈r〉),ML(〈〈r〉〉),ML∅(〈〈r〉〉)}. Given two pointed models 〈M1, w1〉 and 〈M2, w2〉 then 〈M1, w1〉 ≡E F L 〈M2, w2〉 if and only if 〈M1, w1〉 ↔L 〈M2, w2〉. THE EXPRESSIVE POWER OF MEMORY LOGICS 297 Proof. We will discuss the case only for ML(〈r〉) as the proof is similar for languages containing 〈〈r〉〉. For the right to left direction, assume that 〈M1, w1〉 ↔ 〈M2, w2〉 and that ∼ is a bisimulation linking 〈M1, w1〉 and 〈M2, w2〉. We will prove that there is a strategy for Duplicator in the game E F(M1,M2, w1, w2). First note that the game E F(M1,M2, w1, w2) is well defined, since by (agree), w1 and w2 are agreeing states. We show that there is a strategy for Duplicator by proving that (1) for any pair of tuples 〈S, w〉 and 〈Q, v〉 such that 〈S, w〉 ∼ 〈Q, v〉, and for any move Spoiler makes in the game E F(M1[S],M2[Q], w, v), there is always an appropriate answer for Duplicator such that the next step of the game is E F(M1[S′],M2[Q′], w′, v ′) and 〈S′, w′〉 ∼ 〈Q′, v ′〉. Given the initial assumptions, the fact that Duplicator has a winning strategy on the game E F(M1,M2, w1, w2) easily follows from (1). So let us suppose that 〈S, w〉 ∼ 〈Q, v〉 and consider the game E F(M1[S],M2[Q], w, v). Without loss of generality, we assume that Spoiler chooses M1 to make his move. There are two kinds of moves Spoiler can do: • Spoiler make a memorize step, and the game continues with E F(M1[S ∪ {w}], M2[Q ∪ {v}], w, v). By the (remember) condition, we know that 〈S ∪ {w}, w〉 ∼ 〈Q ∪ {v}, v〉. • Spoiler chooses an r -successor w′ of w. By the (forth) condition (we use (back) here if Duplicator chooses M2 for his move), there is an r -successor v ′ of v such that 〈S, w′〉 ∼ 〈Q, v ′〉. Using (agree), we know that w′ and v ′ agree, so v ′ is a good choice for Duplicator. The game continues with E F(M1[S],M2[Q], w′, v ′) and 〈S, w′〉 ∼ 〈Q, v ′〉. For the other direction, suppose that Duplicator has a winning strategy S on the game E F(M1,M2, w1, w2). We define ∼ in the following way: 〈S, w〉 ∼ 〈Q, v〉 if and only if E F(M1[S],M2[Q], w, v) is a reachable state of E F(M1,M2, w1, w2) when Duplicator follows strategy S. We have to prove that the relation ∼ is a bisimulation. Suppose that 〈S, w〉 ∼ 〈Q, v〉. • The condition (agree) is easy to check. • To see that the (forth) condition holds, suppose that (m,m′) ∈ I1(r). One possible move for Spoiler in the game E F(M1[S],M2[Q], w, v) is to choose m′ from M1, and because Duplicator uses the winning strategy S, he can answer with a state v ′ ∈ M2, a successor of v , such that w′ and v ′ agree. Therefore, the next step of the game is E F(M1[S],M2[Q], w′, v ′), and by definition, 〈S, w′〉 ∼ 〈Q, v ′〉. The (back) condition is equivalent. • Finally, to verify the (remember) condition, note that in the game E F(M1[S], M2[Q], w, v) Spoiler can choose to make a memorize step, and therefore the next step of the game is E(M1[S ∪ {w}],M2[Q ∪ {v}], w, v). By definition, that means that 〈S ∪ {w}, w〉 ∼ 〈Q ∪ {v}, v〉. Therefore, ∼ is actually a bisimulation. Because the state E F(M1,M2, w1, w2) is (trivially) reachable, 〈M1, w1〉 ∼ 〈M2, w2〉 as desired. As one could expect, both notions of model equivalence preserve the truth value of formulas. Given two pointed models 〈M1, w1〉 and 〈M2, w2〉, we write 〈M1, w1〉 ≡L 〈M2, w2〉 if for any formula φ in the language of the logic L we have that M1, w1 | φ if and only if M2, w2 | φ. Proving then that 〈M1, w1〉 ≡E F L 〈M2, w2〉 (equivalently 〈M1, w1〉 ↔L 〈M2, w2〉) implies 〈M1, w1〉 ≡L 〈M2, w2〉 only requires a simple induction. Establishing that the notions ≡E F L , ↔L, and ≡L coincide on image-finite models 298 CARLOS ARECES ET AL. (i.e., models where each state has only a finite number of successors considering the union of the accessibility relations) is only slightly harder. THEOREM 3.4. Let L ∈ {ML(〈r〉),ML∅(〈r〉),ML(〈〈r〉〉),ML∅(〈〈r〉〉)}. Let 〈M1, w1〉 and 〈M2, w2〉 be two pointed models. Then 〈M1, w1〉 ≡E F L 〈M2, w2〉 (equivalently, 〈M1, w1〉 ↔L 〈M2, w2〉) implies 〈M1, w1〉 ≡L 〈M2, w2〉. If M1 and M2 are image finite, then 〈M1, w1〉 ≡L 〈M2, w2〉 implies both 〈M1, w1〉 ≡E F L 〈M2, w2〉 and 〈M1, w1〉 ↔L 〈M2, w2〉. §4. Expressive power. In this section we compare the expressive power of memory logics with respect to both modal and hybrid logics. To do this, we will have to find a natural mapping between models of each logic. Such a mapping is easy to define in the case of the ML∅ logics, where we only consider models with an empty memory: each modal model 〈D, I〉 can be identified with the memory model 〈D, I,∅〉. Similarly, for sentences of HL(↓) (i.e., formulas where each nominal i appears in the scope of ↓i) the memory model 〈D, I,∅〉 can be identified with the hybrid model 〈D, I, g〉 for g an arbitrary assignment. In other cases, the definition will involve a change in the signature. But for the moment, assume that we consider two logics L and L′ such that both can be evaluated over the same class of models (modulo representation issues). DEFINITION 4.5 (L ≤ L′). We say that L′ is at least as expressive as L (notation L ≤ L′) if there is a function Tr between formulas of L and L′ such that for every model M and every formula φ of L we have that M | L φ iff M | L′ Tr(φ), (here it should be understood that the model M is seen as a model of L on the left and as a model of L′ on the right, and that we use in each case the appropriate semantic relation | L or | L′ as required). We say that L′ is strictly more expressive than L (notation L < L′) if L ≤ L′ but not L′ ≤ L. And we say that L and L′ are equally expressive (notation L = L′) if L ≤ L′ and L′ ≤ L. To improve the presentation of this section, sometimes we are going to present theorems that are later subsumed by stronger results (e.g., Theorem 4.8 is subsumed by Theorem 4.11, and later by Corollary 4.19). The reasons for doing this are in some cases just for the sake of clarity. In others it is because we believe that the proofs of some results are interesting by themselves. 4.1. Logics with an initially empty memory. We will compare the logics ML∅ with the basic modal logic K and the hybrid logic HL(↓). We are going to establish that K < ML∅(〈〈r〉〉) < ML∅(〈r〉) < HL(↓). First we are going to show that the freedom to decide when to remember a state gives ML∅(〈r〉) more expressive power when compared to ML∅(〈〈r〉〉). THEOREM 4.6. ML∅(〈〈r〉〉) < ML∅(〈r〉). Proof. [ML∅(〈〈r〉〉) ≤ ML∅(〈r〉)]: It is easy to see that there is a translation Tr from ML∅(〈〈r〉〉) to ML∅(〈r〉)-formulas which maps 〈〈r〉〉φ to ©r 〈r〉φ and verifies M | φ if and only if M | Tr(φ). [ML∅(〈r〉) ≤ ML∅(〈〈r〉〉)]: Let M1 = 〈{w, v, x}, I1,∅〉 and M2 = 〈{w, v, x}, I2,∅〉 such that I1(r) = {(w, v), (v, x), (x, w)}, I2(r) = {(w, v), (v, x), (x, v)}, and THE EXPRESSIVE POWER OF MEMORY LOGICS 299 I1(p) = I2(p) = ∅ for p ∈ PROP as shown below: We claim 〈M1, w〉 ≡EF ML(〈〈r〉〉) 〈M2, w〉. As every state in both models has a unique successor, Duplicator has only one way of playing, which is actually a winning strategy. Hence 〈M1, w〉 ≡ML(〈〈r〉〉) 〈M2, w〉. But M1, w | 〈r〉©r 〈r〉〈r〉©k , while M2, w | 〈r〉©r 〈r〉〈r〉©k . We will now compare the expressive power of memory logics with the basic modal logic K. It is not difficult to see intuitively that ©r and ©k do bring additional expressive power into the language of K: with their help we can detect cycles in a given model, while formulas of K are invariant under unraveling. THEOREM 4.7. K < ML∅(〈〈r〉〉). Proof. As K is a csublanguage of ML∅(〈〈r〉〉), K ≤ ML∅(〈〈r〉〉) taking Tr to be the identity function. To see that ML∅(〈〈r〉〉) ≤ K, let M1 = 〈{w}, I1,∅〉 with I1(r) = {(w,w)}, M2 = 〈{u, v}, I2,∅〉 with I2 = {(u, v), (v, u)}, and I1(p) = I2(p) = ∅ for p ∈ props be two models as shown below: The models are K bisimilar (Blackburn et al., 2001). However, they can be distinguished by the ML(〈〈r〉〉)-formula 〈〈r〉〉©k . We will now compare the expressive power of memory logics with respect to hybrid logics. The most natural choice for the comparison is the hybrid logic HL(↓). We will prove that HL(↓) is strictly more expressive than ML∅(〈r〉). Intuitively, ↓ can easily simulate ©r , but ©k does not distinguish between different memorized states (while nominals bound by ↓ do). THEOREM 4.8. ML∅(〈r〉) < HL(↓). Proof. We first prove that ML∅(〈r〉) ≤ HL(↓). We define the translation Tr, taking ML∅(〈r〉)-formulas over the signature 〈PROP, REL〉 to HL(↓)-sentences over the signature 〈PROP, REL, NOM〉. Tr is defined for any finite set N ⊆ NOM as follows: TrN (p) = p p ∈ PROP TrN (©k ) = i∈N i TrN (¬φ) = ¬TrN (φ) TrN (φ1 ∧ φ2) = TrN (φ1) ∧ TrN (φ2) TrN (〈r〉φ) = 〈r〉TrN (φ) TrN (©r φ) = ↓i.TrN∪{i}(φ) where i / ∈ N . Induction then shows that M, w | φ iff M, g, w | Tr∅(φ), for any g. 300 CARLOS ARECES ET AL. Now we prove that HL(↓) is strictly more expressive than ML∅(〈r〉). Let M1 = 〈{w0, w1, w2, . . . }, I1,∅〉 M2 = 〈{w0, w1, w2, . . . }, I2,∅〉 I1(r) = {(n,m) | n = m} ∪ {(w0, w0)} I2(r) = I1(r) ∪ {(w1, w1)} I1(p) = I2(p) = ∅ for p ∈ PROP.